home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Utilities / Unix / cvs-960311 / info / cvsclient.info (.txt) < prev    next >
GNU Info File  |  1996-01-21  |  28KB  |  537 lines
  1. This is Info file cvsclient.info, produced by Makeinfo-1.64 from the
  2. input file ./cvsclient.texi.
  3. File: cvsclient.info,  Node: Top,  Next: Goals,  Up: (dir)
  4. CVS Client/Server
  5. *****************
  6.    This manual describes the client/server protocol used by CVS.  It
  7. does not describe how to use or administer client/server CVS; see the
  8. regular CVS manual for that.
  9. * Menu:
  10. * Goals::             Basic design decisions, requirements, scope, etc.
  11. * Notes::             Notes on the current implementation
  12. * Protocol Notes::    Possible enhancements, limitations, etc. of the protocol
  13. * Protocol::          Complete description of the protocol
  14. File: cvsclient.info,  Node: Goals,  Next: Notes,  Prev: Top,  Up: Top
  15. Goals
  16. *****
  17.    * Do not assume any access to the repository other than via this
  18.      protocol.  It does not depend on NFS, rdist, etc.
  19.    * Providing a reliable transport is outside this protocol.  It is
  20.      expected that it runs over TCP, UUCP, etc.
  21.    * Security and authentication are handled outside this protocol (but
  22.      see below about `cvs kserver').
  23.    * This might be a first step towards adding transactions to CVS
  24.      (i.e. a set of operations is either executed atomically or none of
  25.      them is executed), improving the locking, or other features.  The
  26.      current server implementation is a long way from being able to do
  27.      any of these things.  The protocol, however, is not known to
  28.      contain any defects which would preclude them.
  29.    * The server never has to have any CVS locks in place while it is
  30.      waiting for communication with the client.  This makes things
  31.      robust in the face of flaky networks.
  32.    * Data is transferred in large chunks, which is necessary for good
  33.      performance.  In fact, currently the client uploads all the data
  34.      (without waiting for server responses), and then waits for one
  35.      server response (which consists of a massive download of all the
  36.      data).  There may be cases in which it is better to have a richer
  37.      interraction, but the need for the server to release all locks
  38.      whenever it waits for the client makes it complicated.
  39. File: cvsclient.info,  Node: Notes,  Next: Protocol Notes,  Prev: Goals,  Up: Top
  40. Notes on the Current Implementation
  41. ***********************************
  42.    The client is built in to the normal `cvs' program, triggered by a
  43. `CVSROOT' variable containing a colon, for example
  44. `cygnus.com:/rel/cvsfiles'.
  45.    The client stores what is stored in checked-out directories
  46. (including `CVS').  The way these are stored is totally compatible with
  47. standard CVS.  The server requires no storage other than the repository,
  48. which also is totally compatible with standard CVS.
  49.    The server is started by `cvs server'.  There is no particularly
  50. compelling reason for this rather than making it a separate program
  51. which shares a lot of sources with cvs.
  52.    The server can also be started by `cvs kserver', in which case it
  53. does an initial Kerberos authentication on stdin.  If the authentication
  54. succeeds, it subsequently runs identically to `cvs server'.
  55.    The current server implementation can use up huge amounts of memory
  56. when transmitting a lot of data over a slow link (i.e. the network is
  57. slower than the server can generate the data).  There is some
  58. experimental code (see `SERVER_FLOWCONTROL' in options.h) which should
  59. help significantly.
  60. File: cvsclient.info,  Node: Protocol Notes,  Next: Protocol,  Prev: Notes,  Up: Top
  61. Notes on the Protocol
  62. *********************
  63.    A number of enhancements are possible:
  64.    * The `Modified' request could be speeded up by sending diffs rather
  65.      than entire files.  The client would need some way to keep the
  66.      version of the file which was originally checked out, which would
  67.      double client disk space requirements or require coordination with
  68.      editors (e.g. maybe it could use emacs numbered backups).  This
  69.      would also allow local operation of `cvs diff' without arguments.
  70.    * Have the client keep a copy of some part of the repository.  This
  71.      allows all of `cvs diff' and large parts of `cvs update' and `cvs
  72.      ci' to be local.  The local copy could be made consistent with the
  73.      master copy at night (but if the master copy has been updated since
  74.      the latest nightly re-sync, then it would read what it needs to
  75.      from the master).
  76.    * Provide encryption using kerberos.
  77.    * The current procedure for `cvs update' is highly sub-optimal if
  78.      there are many modified files.  One possible alternative would be
  79.      to have the client send a first request without the contents of
  80.      every modified file, then have the server tell it what files it
  81.      needs.  Note the server needs to do the what-needs-to-be-updated
  82.      check twice (or more, if changes in the repository mean it has to
  83.      ask the client for more files), because it can't keep locks open
  84.      while waiting for the network.  Perhaps this whole thing is
  85.      irrelevant if client-side repositories are implemented, and the
  86.      rcsmerge is done by the client.
  87. File: cvsclient.info,  Node: Protocol,  Prev: Protocol Notes,  Up: Top
  88. The CVS client/server protocol
  89. ******************************
  90.    In the following, `\n' refers to a linefeed and `\t' refers to a
  91. horizontal tab.
  92. * Menu:
  93. * Entries Lines::
  94. * Modes::
  95. * Requests::
  96. * Responses::
  97. * Example::
  98. File: cvsclient.info,  Node: Entries Lines,  Next: Modes,  Up: Protocol
  99. Entries Lines
  100. =============
  101.    Entries lines are transmitted as:
  102.      / NAME / VERSION / CONFLICT / OPTIONS / TAG_OR_DATE
  103.    TAG_OR_DATE is either `T' TAG or `D' DATE or empty.  If it is
  104. followed by a slash, anything after the slash shall be silently ignored.
  105.    VERSION can be empty, or start with `0' or `-', for no user file,
  106. new user file, or user file to be removed, respectively.
  107.    CONFLICT, if it starts with `+', indicates that the file had
  108. conflicts in it.  The rest of CONFLICT is `=' if the timestamp matches
  109. the file, or anything else if it doesn't.  If CONFLICT does not start
  110. with a `+', it is silently ignored.
  111. File: cvsclient.info,  Node: Modes,  Next: Requests,  Prev: Entries Lines,  Up: Protocol
  112. Modes
  113. =====
  114.    A mode is any number of repetitions of
  115.      MODE-TYPE = DATA
  116.    separated by `,'.
  117.    MODE-TYPE is an identifier composed of alphanumeric characters.
  118. Currently specified: `u' for user, `g' for group, `o' for other, as
  119. specified in POSIX.  If at all possible, give these their POSIX meaning
  120. and use other mode-types for other behaviors.  For example, on VMS it
  121. shouldn't be hard to make the groups behave like POSIX, but you would
  122. need to use ACLs for some cases.
  123.    DATA consists of any data not containing `,', `\0' or `\n'.  For
  124. `u', `g', and `o' mode types, data consists of alphanumeric characters,
  125. where `r' means read, `w' means write, `x' means execute, and
  126. unrecognized letters are silently ignored.
  127. File: cvsclient.info,  Node: Requests,  Next: Responses,  Prev: Modes,  Up: Protocol
  128. Requests
  129. ========
  130.    File contents (noted below as FILE TRANSMISSION) can be sent in one
  131. of two forms.  The simpler form is a number of bytes, followed by a
  132. newline, followed by the specified number of bytes of file contents.
  133. These are the entire contents of the specified file.  Second, if both
  134. client and server support `gzip-file-contents', a `z' may precede the
  135. length, and the `file contents' sent are actually compressed with
  136. `gzip'.  The length specified is that of the compressed version of the
  137. file.
  138.    In neither case are the file content followed by any additional data.
  139. The transmission of a file will end with a newline iff that file (or its
  140. compressed form) ends with a newline.
  141. `Root PATHNAME \n'
  142.      Response expected: no.  Tell the server which `CVSROOT' to use.
  143. `Valid-responses REQUEST-LIST \n'
  144.      Response expected: no.  Tell the server what responses the client
  145.      will accept.  request-list is a space separated list of tokens.
  146. `valid-requests \n'
  147.      Response expected: yes.  Ask the server to send back a
  148.      `Valid-requests' response.
  149. `Repository REPOSITORY \n'
  150.      Response expected: no.  Tell the server what repository to use.
  151.      This should be a directory name from a previous server response.
  152.      Note that this both gives a default for `Entry ' and `Modified '
  153.      and also for `ci' and the other commands; normal usage is to send a
  154.      `Repository ' for each directory in which there will be an `Entry
  155.      ' or `Modified ', and then a final `Repository ' for the original
  156.      directory, then the command.
  157. `Directory LOCAL-DIRECTORY \n'
  158.      Additional data: REPOSITORY \n.  This is like `Repository', but
  159.      the local name of the directory may differ from the repository
  160.      name.  If the client uses this request, it affects the way the
  161.      server returns pathnames; see *Note Responses::.  LOCAL-DIRECTORY
  162.      is relative to the top level at which the command is occurring
  163.      (i.e. the last `Directory' or `Repository' which is sent before
  164.      the command).
  165. `Max-dotdot LEVEL \n'
  166.      Tell the server that LEVEL levels of directories above the
  167.      directory which `Directory' requests are relative to will be
  168.      needed.  For example, if the client is planning to use a
  169.      `Directory' request for `../../foo', it must send a `Max-dotdot'
  170.      request with a LEVEL of at least 2.  `Max-dotdot' must be sent
  171.      before the first `Directory' request.
  172. `Static-directory \n'
  173.      Response expected: no.  Tell the server that the directory most
  174.      recently specified with `Repository' or `Directory' should not have
  175.      additional files checked out unless explicitly requested.  The
  176.      client sends this if the `Entries.Static' flag is set, which is
  177.      controlled by the `Set-static-directory' and
  178.      `Clear-static-directory' responses.
  179. `Sticky TAGSPEC \n'
  180.      Response expected: no.  Tell the server that the directory most
  181.      recently specified with `Repository' has a sticky tag or date
  182.      TAGSPEC.  The first character of TAGSPEC is `T' for a tag, or `D'
  183.      for a date.  The remainder of TAGSPEC contains the actual tag or
  184.      date.
  185. `Checkin-prog PROGRAM \n'
  186.      Response expected: no.  Tell the server that the directory most
  187.      recently specified with `Directory' has a checkin program PROGRAM.
  188.      Such a program would have been previously set with the
  189.      `Set-checkin-prog' response.
  190. `Update-prog PROGRAM \n'
  191.      Response expected: no.  Tell the server that the directory most
  192.      recently specified with `Directory' has an update program PROGRAM.
  193.      Such a program would have been previously set with the
  194.      `Set-update-prog' response.
  195. `Entry ENTRY-LINE \n'
  196.      Response expected: no.  Tell the server what version of a file is
  197.      on the local machine.  The name in ENTRY-LINE is a name relative
  198.      to the directory most recently specified with `Repository'.  If
  199.      the user is operating on only some files in a directory, `Entry'
  200.      requests for only those files need be included.  If an `Entry'
  201.      request is sent without `Modified', `Unchanged', or `Lost' for that
  202.      file the meaning depends on whether `UseUnchanged' has been sent;
  203.      if it has been it means the file is lost, if not it means the file
  204.      is unchanged.
  205. `Modified FILENAME \n'
  206.      Response expected: no.  Additional data: mode, \n, file
  207.      transmission.  Send the server a copy of one locally modified
  208.      file.  FILENAME is relative to the most recent repository sent
  209.      with `Repository'.  If the user is operating on only some files in
  210.      a directory, only those files need to be included.  This can also
  211.      be sent without `Entry', if there is no entry for the file.
  212. `Lost FILENAME \n'
  213.      Response expected: no.  Tell the server that FILENAME no longer
  214.      exists.  The name is relative to the most recent repository sent
  215.      with `Repository'.  This is used for any case in which `Entry' is
  216.      being sent but the file no longer exists.  If the client has
  217.      issued the `UseUnchanged' request, then this request is not used.
  218. `Unchanged FILENAME \n'
  219.      Response expected: no.  Tell the server that FILENAME has not been
  220.      modified in the checked out directory.  The name is relative to
  221.      the most recent repository sent with `Repository'.  This request
  222.      can only be issued if `UseUnchanged' has been sent.
  223. `UseUnchanged \n'
  224.      Response expected: no.  Tell the server that the client will be
  225.      indicating unmodified files with `Unchanged', and that files for
  226.      which no information is sent are nonexistent on the client side,
  227.      not unchanged.  This is necessary for correct behavior since only
  228.      the server knows what possible files may exist, and thus what
  229.      files are nonexistent.
  230. `Notify FILENAME \n'
  231.      Tell the server that a `edit' or `unedit' command has taken place.
  232.      The server needs to send a `Notified' response, but such response
  233.      is deferred until the next time that the server is sending
  234.      responses.  Response expected: no.  Additional data:
  235.           NOTIFICATION-TYPE \t TIME \t CLIENTHOST \t
  236.           WORKING-DIR \t WATCHES \n
  237.      where NOTIFICATION-TYPE is `E' for edit or `U' for unedit, TIME is
  238.      the time at which the edit or unedit took place, CLIENTHOST is the
  239.      name of the host on which the edit or unedit took place, and
  240.      WORKING-DIR is the pathname of the working directory where the
  241.      edit or unedit took place.  WATCHES are the temporary watches to
  242.      set; if it is followed by \t then the tab and the rest of the line
  243.      are ignored.
  244. `Questionable FILENAME \n'
  245.      Response expected: no.  Additional data: no.  Tell the server to
  246.      check whether FILENAME should be ignored, and if not, next time the
  247.      server sends responses, send (in a `M' response) `?' followed by
  248.      the directory and filename.
  249. `Argument TEXT \n'
  250.      Response expected: no.  Save argument for use in a subsequent
  251.      command.  Arguments accumulate until an argument-using command is
  252.      given, at which point they are forgotten.
  253. `Argumentx TEXT \n'
  254.      Response expected: no.  Append \n followed by text to the current
  255.      argument being saved.
  256. `Global_option OPTION \n'
  257.      Transmit one of the global options `-q', `-Q', `-l', `-t', `-r',
  258.      or `-n'.  OPTION must be one of those strings, no variations (such
  259.      as combining of options) are allowed.  For graceful handling of
  260.      `valid-requests', it is probably better to make new global options
  261.      separate requests, rather than trying to add them to this request.
  262. `expand-modules \n'
  263.      Response expected: yes.  Expand the modules which are specified in
  264.      the arguments.  Returns the data in `Module-expansion' responses.
  265.      Note that the server can assume that this is checkout or export,
  266.      not rtag or rdiff; the latter do not access the working directory
  267.      and thus have no need to expand modules on the client side.
  268. `co \n'
  269. `ci \n'
  270. `diff \n'
  271. `tag \n'
  272. `status \n'
  273. `log \n'
  274. `add \n'
  275. `remove \n'
  276. `rdiff \n'
  277. `rtag \n'
  278. `admin \n'
  279. `export \n'
  280. `history \n'
  281. `watchers \n'
  282. `editors \n'
  283.      Response expected: yes.  Actually do a cvs command.  This uses any
  284.      previous `Argument', `Repository', `Entry', `Modified', or `Lost'
  285.      requests, if they have been sent.  The last `Repository' sent
  286.      specifies the working directory at the time of the operation.  No
  287.      provision is made for any input from the user.  This means that
  288.      `ci' must use a `-m' argument if it wants to specify a log message.
  289. `update \n'
  290.      Response expected: yes.  Actually do a `cvs update' command.  This
  291.      uses any previous `Argument', `Repository', `Entry', `Modified',
  292.      or `Lost' requests, if they have been sent.  The last `Repository'
  293.      sent specifies the working directory at the time of the operation.
  294.      The `-I' option is not used-files which the client can decide
  295.      whether to ignore are not mentioned and the client sends the
  296.      `Questionable' request for others.
  297. `import \n'
  298.      Response expected: yes.  Actually do a `cvs import' command.  This
  299.      uses any previous `Argument', `Repository', `Entry', `Modified',
  300.      or `Lost' requests, if they have been sent.  The last `Repository'
  301.      sent specifies the working directory at the time of the operation.
  302.      The files to be imported are sent in `Modified' requests (files
  303.      which the client knows should be ignored are not sent; the server
  304.      must still process the CVSROOT/cvsignore file unless -I ! is
  305.      sent).  A log message must have been specified with a `-m'
  306.      argument.
  307. `watch-on \n'
  308. `watch-off \n'
  309. `watch-add \n'
  310. `watch-remove \n'
  311.      Response expected: yes.  Actually do the `cvs watch on', `cvs
  312.      watch off', `cvs watch add', and `cvs watch remove' commands,
  313.      respectively.  This uses any previous `Argument', `Repository',
  314.      `Entry', `Modified', or `Lost' requests, if they have been sent.
  315.      The last `Repository' sent specifies the working directory at the
  316.      time of the operation.
  317. `release \n'
  318.      Response expected: yes.  Note that a `cvs release' command has
  319.      taken place and update the history file accordingly.
  320. `noop \n'
  321.      Response expected: yes.  This request is a null command in the
  322.      sense that it doesn't do anything, but merely (as with any other
  323.      requests expecting a response) sends back any responses pertaining
  324.      to pending errors, pending `Notified' responses, etc.
  325. `update-patches \n'
  326.      This request does not actually do anything.  It is used as a
  327.      signal that the server is able to generate patches when given an
  328.      `update' request.  The client must issue the `-u' argument to
  329.      `update' in order to receive patches.
  330. `gzip-file-contents LEVEL \n'
  331.      This request asks the server to filter files it sends to the client
  332.      through the `gzip' program, using the specified level of
  333.      compression.  If this request is not made, the server must not do
  334.      any compression.
  335.      This is only a hint to the server.  It may still decide (for
  336.      example, in the case of very small files, or files that already
  337.      appear to be compressed) not to do the compression.  Compression
  338.      is indicated by a `z' preceding the file length.
  339.      Availability of this request in the server indicates to the client
  340.      that it may compress files sent to the server, regardless of
  341.      whether the client actually uses this request.
  342. `OTHER-REQUEST TEXT \n'
  343.      Response expected: yes.  Any unrecognized request expects a
  344.      response, and does not contain any additional data.  The response
  345.      will normally be something like `error  unrecognized request', but
  346.      it could be a different error if a previous command which doesn't
  347.      expect a response produced an error.
  348.    When the client is done, it drops the connection.
  349. File: cvsclient.info,  Node: Responses,  Next: Example,  Prev: Requests,  Up: Protocol
  350. Responses
  351. =========
  352.    After a command which expects a response, the server sends however
  353. many of the following responses are appropriate.  Pathnames are of the
  354. actual files operated on (i.e. they do not contain `,v' endings), and
  355. are suitable for use in a subsequent `Repository' request.  However, if
  356. the client has used the `Directory' request, then it is instead a local
  357. directory name relative to the directory in which the command was given
  358. (i.e. the last `Directory' before the command).  Then a newline and a
  359. repository name (the pathname which is sent if `Directory' is not
  360. used).  Then the slash and the filename.  For example, for a file
  361. `i386.mh' which is in the local directory `gas.clean/config' and for
  362. which the repository is `/rel/cvsfiles/devo/gas/config':
  363.      gas.clean/config/
  364.      /rel/cvsfiles/devo/gas/config/i386.mh
  365.    Any response always ends with `error' or `ok'.  This indicates that
  366. the response is over.
  367. `Valid-requests REQUEST-LIST \n'
  368.      Indicate what requests the server will accept.  REQUEST-LIST is a
  369.      space separated list of tokens.  If the server supports sending
  370.      patches, it will include `update-patches' in this list.  The
  371.      `update-patches' request does not actually do anything.
  372. `Checked-in PATHNAME \n'
  373.      Additional data: New Entries line, \n.  This means a file PATHNAME
  374.      has been successfully operated on (checked in, added, etc.).  name
  375.      in the Entries line is the same as the last component of PATHNAME.
  376. `New-entry PATHNAME \n'
  377.      Additional data: New Entries line, \n.  Like `Checked-in', but the
  378.      file is not up to date.
  379. `Updated PATHNAME \n'
  380.      Additional data: New Entries line, \n, mode, \n, file
  381.      transmission.  A new copy of the file is enclosed.  This is used
  382.      for a new revision of an existing file, or for a new file, or for
  383.      any other case in which the local (client-side) copy of the file
  384.      needs to be updated, and after being updated it will be up to
  385.      date.  If any directory in pathname does not exist, create it.
  386. `Merged PATHNAME \n'
  387.      This is just like `Updated' and takes the same additional data,
  388.      with the one difference that after the new copy of the file is
  389.      enclosed, it will still not be up to date.  Used for the results
  390.      of a merge, with or without conflicts.
  391. `Patched PATHNAME \n'
  392.      This is just like `Updated' and takes the same additional data,
  393.      with the one difference that instead of sending a new copy of the
  394.      file, the server sends a patch produced by `diff -u'.  This client
  395.      must apply this patch, using the `patch' program, to the existing
  396.      file.  This will only be used when the client has an exact copy of
  397.      an earlier revision of a file.  This response is only used if the
  398.      `update' command is given the `-u' argument.
  399. `Mode MODE \n'
  400.      This MODE applies to the next file mentioned in `Checked-in'.  It
  401.      does not apply to any request which follows a `Checked-in',
  402.      `New-entry', `Updated', `Merged', or `Patched' response.
  403. `Checksum CHECKSUM\n'
  404.      The CHECKSUM applies to the next file sent over via `Updated',
  405.      `Merged', or `Patched'.  In the case of `Patched', the checksum
  406.      applies to the file after being patched, not to the patch itself.
  407.      The client should compute the checksum itself, after receiving the
  408.      file or patch, and signal an error if the checksums do not match.
  409.      The checksum is the 128 bit MD5 checksum represented as 32 hex
  410.      digits.  This response is optional, and is only used if the client
  411.      supports it (as judged by the `Valid-responses' request).
  412. `Copy-file PATHNAME \n'
  413.      Additional data: NEWNAME \n.  Copy file PATHNAME to NEWNAME in the
  414.      same directory where it already is.  This does not affect
  415.      `CVS/Entries'.
  416. `Removed PATHNAME \n'
  417.      The file has been removed from the repository (this is the case
  418.      where cvs prints `file foobar.c is no longer pertinent').
  419. `Remove-entry PATHNAME \n'
  420.      The file needs its entry removed from `CVS/Entries', but the file
  421.      itself is already gone (this happens in response to a `ci' request
  422.      which involves committing the removal of a file).
  423. `Set-static-directory PATHNAME \n'
  424.      This instructs the client to set the `Entries.Static' flag, which
  425.      it should then send back to the server in a `Static-directory'
  426.      request whenever the directory is operated on.  PATHNAME ends in a
  427.      slash; its purpose is to specify a directory, not a file within a
  428.      directory.
  429. `Clear-static-directory PATHNAME \n'
  430.      Like `Set-static-directory', but clear, not set, the flag.
  431. `Set-sticky PATHNAME \n'
  432.      Additional data: TAGSPEC \n.  Tell the client to set a sticky tag
  433.      or date, which should be supplied with the `Sticky' request for
  434.      future operations.  PATHNAME ends in a slash; its purpose is to
  435.      specify a directory, not a file within a directory.  The first
  436.      character of TAGSPEC is `T' for a tag, or `D' for a date.  The
  437.      remainder of TAGSPEC contains the actual tag or date.
  438. `Clear-sticky PATHNAME \n'
  439.      Clear any sticky tag or date set by `Set-sticky'.
  440. `Set-checkin-prog DIR \n'
  441.      Additional data: PROG \n.  Tell the client to set a checkin
  442.      program, which should be supplied with the `Checkin-prog' request
  443.      for future operations.
  444. `Set-update-prog DIR \n'
  445.      Additional data: PROG \n.  Tell the client to set an update
  446.      program, which should be supplied with the `Update-prog' request
  447.      for future operations.
  448. `Notified PATHNAME \n'
  449.      Indicate to the client that the notification for PATHNAME has been
  450.      done.  There should be one such response for every `Notify'
  451.      request; if there are several `Notify' requests for a single file,
  452.      the requests should be processed in order; the first `Notified'
  453.      response pertains to the first `Notify' request, etc.
  454. `Module-expansion PATHNAME \n Return a file or directory'
  455.      which is included in a particular module.  PATHNAME is relative to
  456.      cvsroot, unlike most pathnames in responses.  PATHNAME should be
  457.      used to look and see whether some or all of the module exists on
  458.      the client side; it is not necessarily suitable for passing as an
  459.      argument to a `co' request (for example, if the modules file
  460.      contains the `-d' option, it will be the directory specified with
  461.      `-d', not the name of the module).
  462. `M TEXT \n'
  463.      A one-line message for the user.
  464. `E TEXT \n'
  465.      Same as `M' but send to stderr not stdout.
  466. `error ERRNO-CODE ` ' TEXT \n'
  467.      The command completed with an error.  ERRNO-CODE is a symbolic
  468.      error code (e.g. `ENOENT'); if the server doesn't support this
  469.      feature, or if it's not appropriate for this particular message,
  470.      it just omits the errno-code (in that case there are two spaces
  471.      after `error').  Text is an error message such as that provided by
  472.      strerror(), or any other message the server wants to use.
  473. `ok \n'
  474.      The command completed successfully.
  475. File: cvsclient.info,  Node: Example,  Prev: Responses,  Up: Protocol
  476. Example
  477. =======
  478.    Lines beginning with `c>' are sent by the client; lines beginning
  479. with `s>' are sent by the server; lines beginning with `#' are not part
  480. of the actual exchange.
  481.      c> Root /rel/cvsfiles
  482.      # In actual practice the lists of valid responses and requests would
  483.      # be longer
  484.      c> Valid-responses Updated Checked-in M ok error
  485.      c> valid-requests
  486.      s> Valid-requests Root co Modified Entry Repository ci Argument Argumentx
  487.      s> ok
  488.      # cvs co devo/foo
  489.      c> Argument devo/foo
  490.      c> co
  491.      s> Updated /rel/cvsfiles/devo/foo/foo.c
  492.      s> /foo.c/1.4/Mon Apr 19 15:36:47 1993 Mon Apr 19 15:36:47 1993//
  493.      s> 26
  494.      s> int mein () { abort (); }
  495.      s> Updated /rel/cvsfiles/devo/foo/Makefile
  496.      s> /Makefile/1.2/Mon Apr 19 15:36:47 1993 Mon Apr 19 15:36:47 1993//
  497.      s> 28
  498.      s> foo: foo.c
  499.      s>         $(CC) -o foo $<
  500.      s> ok
  501.      # In actual practice the next part would be a separate connection.
  502.      # Here it is shown as part of the same one.
  503.      c> Repository /rel/cvsfiles/devo/foo
  504.      # foo.c relative to devo/foo just set as Repository.
  505.      c> Entry /foo.c/1.4/Mon Apr 19 15:36:47 1993 Mon Apr 19 15:36:47 1993//
  506.      c> Entry /Makefile/1.2/Mon Apr 19 15:36:47 1993 Mon Apr 19 15:36:47 1993//
  507.      c> Modified foo.c
  508.      c> 26
  509.      c> int main () { abort (); }
  510.      # cvs ci -m <log message> foo.c
  511.      c> Argument -m
  512.      c> Argument Well, you see, it took me hours and hours to find this typo and I
  513.      c> Argumentx searched and searched and eventually had to ask John for help.
  514.      c> Argument foo.c
  515.      c> ci
  516.      s> Checked-in /rel/cvsfiles/devo/foo/foo.c
  517.      s> /foo.c/1.5/ Mon Apr 19 15:54:22 CDT 1993//
  518.      s> M Checking in foo.c;
  519.      s> M /cygint/rel/cvsfiles/devo/foo/foo.c,v  <--  foo.c
  520.      s> M new revision: 1.5; previous revision: 1.4
  521.      s> M done
  522.      s> ok
  523. Tag Table:
  524. Node: Top
  525. Node: Goals
  526. Node: Notes
  527. Node: Protocol Notes
  528. Node: Protocol
  529. Node: Entries Lines
  530. Node: Modes
  531. Node: Requests
  532. Node: Responses
  533. 18751
  534. Node: Example
  535. 25813
  536. End Tag Table
  537.